home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / castools.zip / FAXSUBMI.C < prev    next >
Text File  |  1990-01-05  |  14KB  |  379 lines
  1.  
  2.  
  3. /*
  4.    FAXSPECI.C  The second high-level CAS Toolkit function.
  5.  
  6.    This function submits a send task to the Resident Manager of the
  7.    communications hardware.  It sets all communications options using its own
  8.    parameters.
  9.  
  10.    INPUT:  A complete Event Control structure plus optional
  11.            "who, what, and when" parameters to override some fields
  12.            in the structure.
  13.  
  14.    OUTPUT: The Event handle if successful, otherwise 0.
  15. */
  16.  
  17. #include <string.h>
  18. #include <stdlib.h>
  19. #include <stdio.h>
  20. #include <malloc.h>
  21. #include <cas.h>
  22. #include <fax.h>
  23.  
  24. int pascal FAXSubmitTask(ECS *TaskSettings,
  25.                           char *to,
  26.                           char *PhoneNumber,
  27.                           FILELIST *files,
  28.                           CAS_DATE *date,
  29.                           CAS_TIME *time)
  30. {
  31.   ECS SaveECS;                        /* to be copy of original for restoring */
  32.   FILELIST *CurrFile = NULL;          /* temp for caller's list of files  */
  33.   FTRLIST *CurrFTRL = NULL,
  34.           *NextFTRL = NULL,
  35.           *LastFTRL;                  /* for building or freeing list of FTR's*/
  36.   int FileCount;                      /* number of files to send for TCF */
  37.   SFTR *SingleFileSend = NULL;        /* In case there is only one file */
  38.   int retval = 0;                     /* for CAS function return */
  39.   EDB *EDBbuffer = NULL;              /* for CAS call GetExternalData */
  40.   char *TCFfilename = NULL;           /* tmpnam allocates the space  */
  41.   FILE *fptr = NULL;                  /* Stream pointer for TCF */
  42.   int writ;                           /* To catch errors: # of items written */
  43.   int i;                              /* just a loop counter */
  44.   int CoverLength = TaskSettings->EventControlFile.FTROffset - 383;
  45.                      /* (If no cover, FTROffset equals 383, see DCA/Intel CAS */
  46.  
  47.   FAXerrno = CASerrorcode = 0;      /* They keep it if nothing goes wrong */
  48.  
  49.   /* Whether we use all it's fields or not, check the ECS parameter anyway */
  50.   if (!(ECSOkToSubmit(TaskSettings))) {
  51.     FAXerrno = INVALIDECS;            /* But only a warning at this point */
  52.   }
  53.  
  54.   /* In case of error after changing TaskSettings fields, to restore it */
  55.   memcpy(&SaveECS, TaskSettings, sizeof(ECS));
  56.  
  57.   /* First, assign whatever Event fields the caller specified */
  58.   if (to) {
  59.     strncpy(TaskSettings->EventControlFile.DestinationName, to, NAMELENGTH);
  60.     if (TaskSettings->EventControlFile.DestinationName[NAMELENGTH-1]) {
  61.       FAXerrno = STRINGTOOLONG;
  62.       TaskSettings->EventControlFile.DestinationName[NAMELENGTH-1] = '\0';
  63.     }
  64.   }
  65.   if (PhoneNumber) {
  66.       strncpy(TaskSettings->EventControlFile.Phone,
  67.               PhoneNumber,
  68.               PHONENUMLENGTH);
  69.       if (TaskSettings->EventControlFile.Phone[PHONENUMLENGTH-1]) {
  70.         FAXerrno = STRINGTOOLONG;
  71.         TaskSettings->EventControlFile.Phone[PHONENUMLENGTH-1] = '\0';
  72.       }
  73.   }
  74.   if (time) {
  75.     if (ValidTime(time)) {
  76.       TaskSettings->EventControlFile.EventTime = ((int)time->Second / 2) |
  77.                                                  ((int)time->Minute << 5) |
  78.                                                  ((int)time->Hour << 11);
  79.     }
  80.     else {
  81.       FAXerrno = BADEVENTTIME;
  82.       goto closeup;
  83.     }
  84.   }
  85.   if (date) {
  86.  
  87.     /* Check date for validity only if it's non-zero */
  88.     if (date->Day || date->Month || date->Year) {
  89.       if (ValidDate(date)) {
  90.         TaskSettings->EventControlFile.EventDate = (int)date->Day |
  91.                                                    ((int)date->Month << 5) |
  92.                                                    (((int)date->Year - 1980) << 9);
  93.       }
  94.       else {
  95.         FAXerrno = BADEVENTDATE;
  96.         goto closeup;
  97.       }
  98.     }
  99.     else {
  100.       TaskSettings->EventControlFile.EventDate = 0;
  101.     }
  102.   }
  103.  
  104.   /* Next, if files specified, build and connect up list of FTR structures */
  105.   if (files) {
  106.  
  107.     /* If the given Event Control structure already has an FTRL list, it will */
  108.     /* be lost, but go ahead and replace it with caller's list */
  109.     if (TaskSettings->FirstFTR) {
  110.       FAXerrno = LOSTFTRS;                /* warning only */
  111.     }
  112.  
  113.     /* Build a list of File Transfer Records using the caller's file list */
  114.     CurrFile = files;
  115.     for (FileCount = 0;
  116.          CurrFile;                                    /* while more files */
  117.          FileCount++, CurrFile = CurrFile->next) {
  118.  
  119.       NextFTRL = (FTRLIST *)calloc(sizeof(FTRLIST), 1);
  120.       if (!NextFTRL) {
  121.         FAXerrno = OUTOFMEMORY;
  122.  
  123.         /* If first time through, prevent freeing the caller's FTRLIST */
  124.         if (!FileCount) {
  125.           memcpy(TaskSettings, &SaveECS, sizeof(ECS));
  126.           return(0);
  127.         }
  128.         else goto closeup;
  129.       }
  130.       if (!FileCount) {                       /* if the first */
  131.         TaskSettings->FirstFTR = NextFTRL;    /* point ECS to it */
  132.       }
  133.       else {
  134.         CurrFTRL->next = NextFTRL;    /* Otherwise connect it to the latest */
  135.       }
  136.       CurrFTRL = NextFTRL;          /* in any case, make latest the current */
  137.       strncpy(CurrFTRL->OneFTR.FileName, CurrFile->FileName, FULLFNAMELENGTH);
  138.       if (CurrFTRL->OneFTR.FileName[FULLFNAMELENGTH-1]) {
  139.         FAXerrno = STRINGTOOLONG;
  140.         CurrFTRL->OneFTR.FileName[FULLFNAMELENGTH-1] = '\0';
  141.       }
  142.  
  143.       /* IF faxing, set the fax-specific fields from the DefaultsFTRL */
  144.       if (TaskSettings->EventControlFile.TransferType != FILE_TRANSFER) {
  145.         CurrFTRL->OneFTR.FileType = CurrFile->FileType;
  146.         CurrFTRL->OneFTR.TextSize = DefaultsFTRL.OneFTR.TextSize;
  147.         CurrFTRL->OneFTR.AddPageIncrements = DefaultsFTRL.OneFTR.AddPageIncrements;
  148.         CurrFTRL->OneFTR.PageLength = DefaultsFTRL.OneFTR.PageLength;
  149.       }  /* no else: just leaving them all 0's is correct for file transfers */
  150.  
  151.       CurrFTRL->next = NULL;
  152.     }                                /* end of for (all caller files) loop */
  153.     TaskSettings->EventControlFile.FileCount = FileCount;
  154.  
  155.   }   /* end of if (files); no else:  FirstFTR already points to an FTRLIST */
  156.       /*  and whether the FileCount field is correct will be checked below */
  157.  
  158.   /* If only one file, and none of the fields ignored by the SubmitSingleFile
  159.      function are set, use SubmitSingleFile. */
  160.   if (SubmitSingleOk(TaskSettings) &&
  161.       TaskSettings->EventControlFile.FileCount == 1) {
  162.  
  163.     if (!TaskSettings->FirstFTR) {
  164.       FAXerrno = BADFILECOUNT;
  165.       goto closeup;
  166.     }
  167.  
  168.     SingleFileSend = (SFTR *)calloc(sizeof(SFTR) + CoverLength, 1);
  169.     if (!SingleFileSend) {
  170.       FAXerrno = OUTOFMEMORY;
  171.       goto closeup;
  172.     }
  173.  
  174.     /* Set SFTR fields from the TaskSettings */
  175.     SingleFileSend->TransferType = TaskSettings->EventControlFile.TransferType;
  176.  
  177.     if (SingleFileSend->TransferType != FILE_TRANSFER) {  /* then it's a fax */
  178.       SingleFileSend->TextSize = TaskSettings->FirstFTR->OneFTR.TextSize;
  179.     }
  180.  
  181.     /* Set the date and time fields */
  182.     SingleFileSend->EventTime = TaskSettings->EventControlFile.EventTime;
  183.     SingleFileSend->EventDate = TaskSettings->EventControlFile.EventDate;
  184.     strncpy(SingleFileSend->DestinationName,
  185.             TaskSettings->EventControlFile.DestinationName,
  186.             NAMELENGTH);
  187.     if (SingleFileSend->DestinationName[NAMELENGTH-1]) {
  188.       FAXerrno = STRINGTOOLONG;
  189.       SingleFileSend->DestinationName[NAMELENGTH-1] = '\0';
  190.     }
  191.     strncpy(SingleFileSend->FileName,
  192.             TaskSettings->FirstFTR->OneFTR.FileName,
  193.             FULLFNAMELENGTH);
  194.     if (SingleFileSend->FileName[FULLFNAMELENGTH-1]) {
  195.       FAXerrno = STRINGTOOLONG;
  196.       SingleFileSend->FileName[FULLFNAMELENGTH-1] = '\0';
  197.     }
  198.     if (TaskSettings->FirstFTR->next) {
  199.       FAXerrno = MOREFTRSTHANFC;
  200.     }
  201.     strncpy(SingleFileSend->Phone,
  202.             TaskSettings->EventControlFile.Phone,
  203.             PHONENUMLENGTH);
  204.     if (SingleFileSend->Phone[PHONENUMLENGTH-1]) {
  205.       FAXerrno = STRINGTOOLONG;
  206.       SingleFileSend->Phone[PHONENUMLENGTH-1] = '\0';
  207.     }
  208.     strncpy(SingleFileSend->ApplicationTag,
  209.             TaskSettings->EventControlFile.ApplicationTag,
  210.             APPTAGLENGTH);
  211.     if (SingleFileSend->ApplicationTag[APPTAGLENGTH-1]) {
  212.       FAXerrno = STRINGTOOLONG;
  213.       SingleFileSend->ApplicationTag[APPTAGLENGTH-1] = '\0';
  214.     }
  215.  
  216.     /* Finally, copy in the coverpage text.  Enough memory is guaranteed by */
  217.     /*   how the SingleFileSend structure was allocated. */
  218.     SingleFileSend->SendCover = TaskSettings->EventControlFile.SendCover;
  219.     if (CoverLength && TaskSettings->CoverPageText) {
  220.       strncpy(&SingleFileSend->CoverTextDummy,
  221.               TaskSettings->CoverPageText,
  222.               CoverLength);
  223.       if ((&SingleFileSend->CoverTextDummy)[CoverLength-1]) {
  224.         FAXerrno = STRINGTOOLONG;
  225.         (&SingleFileSend->CoverTextDummy)[CoverLength-1] = '\0';
  226.       }
  227.     }
  228.  
  229.     /* All done setting up, nothing left but to check and ship it! */
  230.     if (SFTROkToSubmit(SingleFileSend)) {
  231.       retval = CASSubmitSingleFile(SingleFileSend);
  232.       if (retval < 0) {
  233.         FAXerrno = SUBMITSINGLE;
  234.       }
  235.       goto closeup;
  236.     }
  237.     else {
  238.       retval = 0;
  239.       goto closeup;
  240.     }
  241.   }
  242.   else {
  243.  
  244.     /* If any of the fields common with the External Data Block are not       */
  245.     /*    initialized, get the EDB and use it */
  246.     if ((TaskSettings->EventControlFile.SenderName[0] == '\0') ||
  247.         (TaskSettings->EventControlFile.LogoFilePath[0] == '\0')) {
  248.       EDBbuffer = (EDB *)malloc(sizeof(EDB));
  249.       if (!EDBbuffer) {
  250.         FAXerrno = OUTOFMEMORY;
  251.         goto closeup;
  252.       }
  253.       retval = CASGetExternalData(EDBbuffer);
  254.       if (retval) {
  255.         FAXerrno = GETEDB;
  256.         goto closeup;
  257.       }
  258.       else {
  259.         if (TaskSettings->EventControlFile.SenderName[0] == '\0') {
  260.           strncpy(TaskSettings->EventControlFile.SenderName,
  261.                   EDBbuffer->DefaultSender,
  262.                   NAMELENGTH);
  263.           if (TaskSettings->EventControlFile.SenderName[NAMELENGTH-1]) {
  264.             FAXerrno = STRINGTOOLONG;
  265.             TaskSettings->EventControlFile.SenderName[NAMELENGTH-1] = '\0';
  266.           }
  267.         }
  268.         if (TaskSettings->EventControlFile.LogoFilePath[0] == '\0') {
  269.           strncpy(TaskSettings->EventControlFile.LogoFilePath,
  270.                   EDBbuffer->DefaultDir,
  271.                   FULLFNAMELENGTH);   /* this pads out whole field with '\0's */
  272.           if (TaskSettings->EventControlFile.LogoFilePath[DIRPATHLENGTH-1]) {
  273.             FAXerrno = STRINGTOOLONG;
  274.             TaskSettings->EventControlFile.LogoFilePath[DIRPATHLENGTH-1] = '\0';
  275.           }
  276.           strncat(TaskSettings->EventControlFile.LogoFilePath,
  277.                   EDBbuffer->DefaultLogo,
  278.                   FNAMELENGTH);
  279.           if (TaskSettings->EventControlFile.LogoFilePath[FULLFNAMELENGTH-1]) {
  280.             FAXerrno = STRINGTOOLONG;
  281.             TaskSettings->EventControlFile.LogoFilePath[FULLFNAMELENGTH-1] = '\0';
  282.           }
  283.         }
  284.         free(EDBbuffer);
  285.       }
  286.     }
  287.  
  288.     /* The Event Control Structure is complete: test and ship it! */
  289.     if (ECSOkToSubmit(TaskSettings)) {
  290.  
  291.       /* Write the Task Control File and submit it*/
  292.       TCFfilename = tmpnam(NULL);
  293.  
  294.       if((fptr = fopen(TCFfilename, "wb")) == NULL) {
  295.          FAXerrno = CANTOPENFILE;
  296.          goto closeup;
  297.       }
  298.  
  299.       /* Write the TCF data to disk. */
  300.       writ = fwrite(&TaskSettings->EventControlFile, sizeof(ECF), 1, fptr);
  301.       if (writ < 1) {
  302.         FAXerrno = CANTWRITEFILE;
  303.         goto closeup;
  304.       }
  305.  
  306.       /* Whether to write cover text depends only on CoverLength, not SendCover*/
  307.       if (CoverLength) {
  308.         writ = fwrite(TaskSettings->CoverPageText, CoverLength, 1, fptr);
  309.         if (writ < 1) {
  310.           FAXerrno = CANTWRITEFILE;
  311.           goto closeup;
  312.         }
  313.       }
  314.  
  315.       /* Now write the FTR's */
  316.       for (CurrFTRL = TaskSettings->FirstFTR, FileCount = 0;
  317.            FileCount < TaskSettings->EventControlFile.FileCount;
  318.            CurrFTRL = CurrFTRL->next, FileCount++) {
  319.  
  320.         if (!CurrFTRL) {
  321.           FAXerrno = BADFILECOUNT;
  322.           goto closeup;
  323.         }
  324.         writ = fwrite(&CurrFTRL->OneFTR, sizeof(FTR), 1, fptr);/* all the FTR's */
  325.         if (writ < 1) {
  326.           FAXerrno = CANTWRITEFILE;
  327.           goto closeup;
  328.         }
  329.       }
  330.  
  331.       if (CurrFTRL) {
  332.         FAXerrno = MOREFTRSTHANFC;            /* warning only */
  333.       }
  334.  
  335.       if (fclose(fptr)) {
  336.         FAXerrno = CANTCLOSEFILE;
  337.         goto closeup;
  338.       }
  339.       else {
  340.         fptr = NULL;              /* prevents trying to close it again */
  341.       }
  342.  
  343.       /* Finally, submit! */
  344.       retval = CASSubmitTask(TCFfilename);
  345.       if (retval < 0) {
  346.         FAXerrno = SUBMITTASK;
  347.       }
  348.     }
  349.     else {              /* ECS was not Ok, FAXerrno was set */
  350.       retval = 0;
  351.     }
  352.   }  /* end of else: there were multiple files, so use a TCF */
  353.  
  354. closeup:
  355.   if (SingleFileSend) {
  356.     free(SingleFileSend);
  357.   }
  358.   if (TaskSettings->FirstFTR != SaveECS.FirstFTR) {
  359.     free_FTRLIST(TaskSettings->FirstFTR);
  360.   }
  361.   if (EDBbuffer) {
  362.     free(EDBbuffer);
  363.   }
  364.   if (fptr) {
  365.     fclose(fptr);
  366.   }
  367.   if (TCFfilename) {
  368.     remove(TCFfilename);
  369.   }
  370.   if (retval <= 0) {
  371.     CASerrorcode = -retval;
  372.     memcpy(TaskSettings, &SaveECS, sizeof(ECS));
  373.     return(0);
  374.   }
  375.   else {
  376.     return(retval);
  377.   }
  378. }
  379.